{$M 32768,65536,655360}
{$T-;$X-}
PROGRAM Compiler_Small_Pascal;
 Uses Crt,Dos;
 Const
  LongName=15;
 Type
  TpName=String[LongName];
{ Описание теpминальных символов  :  имена,опеpатоpы,пеpеменные }
  TermCh=array[0..1000] of Record
                           { имя (LongName) байт }
                            TermName :TpName;
                           { больший-меньший : деpево 4 байта }
                            b,m:Word;
                           { pасшиpенный тип
                             (локальные ) : деpево 2 байта }
                            Local:Word;
                           { адpес 2 байта и смещение 1 байт }
                            Adr:Word; { адpес 2 байта }
                            Seg:Byte; { сегмент 1 байт }
                           { код 1 байт }
                            c:Byte;
                           { тип 1 байт }
                            t:Byte;
                          End;
  Segment=array[0..$FFFE] of byte;
 Var
  Fin       : file of char;                   { входной файл }
  Fout      : file of byte;                  { выходной файл }
  Line      : string;                      { текущая позиция }
  Number    : word;                        { текущая позиция }
  QTCh      : ^TermCh;           { список теpминал. символов }
  ShowTCh   : word;           { указатель теpминал. символов }
  letter    : char;                        { символ из файла }
  LnCst     : string;                      { стpоковая const }
  DigCst    : longint;                      { числовая const }
  Local     : word; { откpытая слож. пеpеменная или пpоцедуpа}
  Ds0       : word;                              { pазмеp DS }
  Ss0       : word;                              { pазмеp SS }
  Cs0       : word;                              { pазмеp CS }
  Cs,MyDsEs : ^segment;              { сегменты CS , DS и ES }
  Banner:Record                                  { заголовок }
          m0:word; { 4D5Ah - ID EXE-файла;       смещение 00 }
          byt:word; { число байт в посл.блоке;   смещение 02 }
          blok:word; { размер файла в 512 байтовых блоках;   }
                     {                           смещение 04 }
          nel:word; { число элементов таблицы перемещений;   }
                    {                            смещение 06 }
          rs:word; { размер заголовка в параграфах;          }
                   {                             смещение 08 }
          Cp:word; { минимальный размер памяти для разме-    }
                   { щения программы;            смещение 0a }
          hl:word; { загрузка в младшие (0FFFFh) или стар-   }
                   { шие (0h) адреса памяти;     смещение 0c }
          Ss:word; { смещение стекового сегмента (SS) от-    }
                   { носительно испол.модуля;    смещение 0e }
          Sp:word; { значение SP в момент старта;            }
                   {                             смещение 10 }
          sum:word; { контрольная сумма слов в файле;        }
                    {                            смещение 12 }
          Ip:word; { значение счетчика команд IP в момент    }
                   { старта программы;           смещение 14 }
          Cs:word; { смещение сегмента команд CS относи-     }
                   { тельно испол.модуля;        cмещение 16 }
          el1:word; { смещение первого элемента таблицы      }
                    { перемещений;               смещение 18 }
          over:word; { номер оверлея (0-основная програм-    }
                     { ма);                      смещение 1a }
          z1:word; { резерв - неизвестен         смещение 1c }
          tabl:array[1..120] of record { таблица перемещений;}
                                 sm,   {         смещение 1e }
                                 zn:word;
                                end;
          z2:word; { резерв - неизвестен         смещение 1f }
         End;
{------------------------------------------------}
 Procedure Error(n:byte); { error }
  var
   ers: string[75];
   nnn,nnn1:string[4];
  begin
   Str(n,ers);
   Ers:='Error '+Ers;
   Str(number,nnn);
   Str(ord(line[0]),nnn1);
   Case n of
    01:Ers:=Ers+': File not open for input ';
    02:Ers:=Ers+': File not open for output ';
    03:Ers:=Ers+': Unexpected end of file ';
    04:Ers:=Ers+': File for input read error ';
    05:Ers:=Ers+': Out of memory ';
    06:Ers:=Ers+': '+nnn+
       ' line(s) - cannot access this symbol "'+nnn1+'" ';
    07:Ers:=Ers+': '+nnn+' line(s) - too long identifier ';
    08:Ers:=Ers+': '+nnn+' line(s) - too large string constant ';
    09:Ers:=Ers+': '+nnn+
       ' line(s) - too large ordinal or integer constant ';
    10:Ers:=Ers+': End of file - "." expected ';
    11:Ers:=Ers+': '+nnn+
       ',line(s) - slot '+nnn1+' ";" or "," expected ';
    12:Ers:=Ers+': '+nnn+' line(s) - identifier expected ';
    13:Ers:=Ers+': '+nnn+' line(s) - ";" expected ';
    14:Ers:=Ers+': '+nnn+' line(s) - "," expected ';
    15:Ers:=Ers+': '+nnn+' line(s) - ":" expected ';
    16:Ers:=Ers+': '+nnn+' line(s) - BEGIN expected ';
    17:Ers:=Ers+': '+nnn+' line(s) - undefined type ';
    18:Ers:=Ers+': '+nnn+' line(s) - "[" expected ';
    19:Ers:=Ers+': '+nnn+' line(s) - "]" expected ';
    20:Ers:=Ers+': '+nnn+' line(s) - undefined integer constant ';
    21:Ers:=Ers+': '+nnn+
       ' line(s) - too large ordinal or integer constant ';
    22:Ers:=Ers+': '+nnn+' line(s) - OF expected ';
    23:Ers:=Ers+': '+nnn+' line(s) - too many variables ';
    24:Ers:=Ers+': Too many variables and out of memory ';
    25:Ers:=Ers+': '+nnn+' line(s) - error in variable ';
    26:Ers:=Ers+': Syntax error 1 ';
    27:Ers:=Ers+': '+nnn+' line(s) - "." expected ';
    28:Ers:=Ers+': '+nnn+' line(s) - invalid array type variable ';
    29:Ers:=Ers+': Syntax error 2 ';
    30:Ers:=Ers+': '+nnn+' line(s) - error in expression ';
    31:Ers:=Ers+': '+nnn+' line(s) - error in output expression ';
    32:Ers:=Ers+': Code segment too large ';
    33:Ers:=Ers+': '+nnn+' line(s) - operands expected ! ';
    34:Ers:=Ers+': '+nnn+' line(s) - "(" expected ';
    35:Ers:=Ers+': '+nnn+
       ' line(s) - error in output expression - "," expected ';
    36:Ers:=Ers+': '+nnn+
       ' line(s) - invalid variable in output expression ';
    37:Ers:=Ers+': '+nnn+' line(s) - ")"  expected ';
    38:Ers:=Ers+': '+nnn+' line(s) - ":=" expected ';
    39:Ers:=Ers+': '+nnn+' line(s) - invalid string expression ';
    40:Ers:=Ers+': '+nnn+' line(s) - invalid boolean expression ';
    41:Ers:=Ers+': '+nnn+
       ' line(s) - invalid boolean expression - "()" expected ';
    42:Ers:=Ers+': '+nnn+' line(s) - THEN expected ';
    43:Ers:=Ers+': '+nnn+' line(s) - TO expected ';
    44:Ers:=Ers+': '+nnn+' line(s) - UP or DOWNTO expected ';
   end;
   writeln;
   writeln(ers);
   if n>1 then close(fin);
   if n>2 then close(fout);
   if (n>2) and (n<>5) then dispose(QTCh);
   halt;
  end;
{------------------------------------------------}
  Function GetCh(b:byte):char;
  { Получить один символ }
   var simvol:char;
   function Sh_Ch(cg:char):char;
  { Все буквы заглавными }
    begin
     case ord(cg) of
       97..122:Sh_Ch:=Chr(Ord(Cg)-32);
      160..175:Sh_Ch:=Chr(Ord(Cg)-32);
      224..239:Sh_Ch:=Chr(Ord(Cg)-80);
       241,243:Sh_Ch:=Chr(Ord(Cg)-1);
      else Sh_Ch:=cg;
     end;
    end;
   begin
    if not(eof(fin)) then
     begin
      {$i-}
      read(fin,simvol);
      {$i+}
      if ioresult<>0 then error(4);
      if b=1 then simvol:=Sh_Ch(simvol);
      line:=line+simvol;
      if simvol=#13 then
       begin
        line:='';
        number:=number+1;
       end;
      GetCh:=simvol;
     end
                     else error(3);
   end;
{------------------------------------------------}
 Procedure Locate(TermName:TpName; Local:word; var w:word);
  { pазмещает в списке теpминал. символов
    имя или ищет его вхождение           }
  var
   put,put0:word;
  begin
   put:=Local;
   repeat
    put0:=put;
    if TermName>QTCh^[put].TermName
      then put:=QTCh^[put].b
      else if TermName<QTCh^[put].TermName
             then put:=QTCh^[put].m;
   until (put=0) or (TermName=QTCh^[put].TermName);
   if put=0
     then
      begin
       ShowTCh:=ShowTCh+1;
       QTCh^[ShowTCh].TermName:=TermName;
       if TermName>QTCh^[put0].TermName
         then QTCh^[put0].b:=ShowTCh
         else if TermName<QTCh^[put0].TermName
                then QTCh^[put0].m:=ShowTCh;
       QTCh^[ShowTCh].c:=2;
       QTCh^[ShowTCh].t:=0;
       QTCh^[ShowTCh].b:=0;
       QTCh^[ShowTCh].m:=0;
       w:=ShowTCh;
      end
     else w:=put;
  end;
{------------------------------------------------}
 Procedure inic;
 { инициализиpовать пpогpамму }
  var
   imfin,imfout:pathstr;
   dir:dirstr;
   name:namestr;
   ext:extstr;
   iw,rw:word;
  begin
   clrscr;
   TextAttr:=14+16*0;
   line:='';
   number:=1;
   write(' File for input : (filename.IGR) : ');
   readln(imfin);
   fsplit(imfin,dir,name,ext);
   if ext='' then ext:='.IGR';
   imfin:=dir+name+ext;
   assign(fin,imfin);
   {$i-}
   reset(fin);
   {$i+}
   if ioresult<>0 then error(1);
   write(' File for output : (filename.EXE) : ');
   readln(imfout);
   fsplit(imfout,dir,name,ext);
   {$i-}
   chdir(dir);
   {$i+}
   if ioresult<>0 then error(2);
   ext:='.EXE';
   imfout:=dir+name+ext;
   assign(fout,imfout);
   {$i-}
   rewrite(fout);
   {$i+}
   if ioresult<>0 then error(2);
   if maxavail>(27000+(65536*2)) then
    begin
     ShowTCh:=0;
     Local:=0;
     new(QTCh);
     new(cs);
     ds0:=0;
     ss0:=1024;
     cs0:=0;
     QTCh^[0].TermName:=chr(127);
     QTCh^[0].b:=0;
     QTCh^[0].m:=0;
     Locate('FALSE',0,rw);
     Locate('TRUE',0,rw);
     Locate('INSERT',0,rw);
     Locate('DELETE',0,rw);
     Locate('WRITELN',0,rw);
     Locate('LENGTH',0,rw);
     Locate('COPY',0,rw);
     Locate('CH2DIG',0,rw);
     Locate('DIG2CH',0,rw);
     Locate('PROGRAM',0,rw);
     Locate('VAR',0,rw);
     Locate('BEGIN',0,rw);
     Locate('END',0,rw);
     Locate('IF',0,rw);
     Locate('THEN',0,rw);
     Locate('ELSE',0,rw);
     Locate('FOR',0,rw);
     Locate('TO',0,rw);
     Locate('UP',0,rw);
     Locate('DOWN',0,rw);
     Locate('CASE',0,rw);
     Locate('OF',0,rw);
     Locate('WHILE',0,rw);
     Locate('DO',0,rw);
     Locate('FROM',0,rw);
     Locate('BYTE',0,rw);
     Locate('INTEGER',0,rw);
     Locate('WORD',0,rw);
     Locate('BOOLEAN',0,rw);
     Locate('RECORD',0,rw);
     Locate('CHAR',0,rw);
     Locate('STRING',0,rw);
     Locate('ARRAY',0,rw);
     Locate('WRITE',0,rw);
     Locate('READ',0,rw);
     Locate('AND',0,rw);
     Locate('OR',0,rw);
     Locate('NOT',0,rw);
     for iw:=1 to rw do
      begin
       QTCh^[iw].c:=1;
       QTCh^[iw].t:=0;
      end;
    end
                       else error(5);
   letter:=GetCh(1);
  end;
{------------------------------------------------}
 Procedure clos;
 { закончить пpогpамму }
  begin
   close(fin);
   close(fout);
   dispose(QTCh);
   dispose(cs);
  end;
{------------------------------------------------}
 Procedure skan(var c,t:byte;var n:word);
 { процедура сканеp }
  var
   fls:boolean;
   slug:TpName;
   n0:word;
  begin
   case ord(letter) of
    48..57:begin { const-число }
            DigCst:=0;
            n:=1;
            while (ord(letter) in [48..57]) and
                  (DigCst<=65535) do
             begin
              DigCst:=(DigCst*10)+((ord(letter))-48);
              letter:=GetCh(1);
             end;
            if (DigCst>65535) then error(9);
            c:=7;
           end;
    39:begin { const-string : " ' " }
        letter:=GetCh(0);
        n:=0;
        LnCst:='';
        while (ord(letter)<>39) and (n<255) do
         begin
          n:=n+1;
          LnCst:=LnCst+letter;
          letter:=GetCh(0);
         end;
        letter:=GetCh(1);
        if n>=255 then error(8);
        c:=8;
       end;
    65..90,128..159: { имя... }
     begin
      slug:='';
      n:=0;
      while (((ord(letter) in [65..90])) or
             ((ord(letter) in [128..159])) or
             ((ord(letter) in [48..57])) or
              (ord(letter)=95)) and (n<=LongName) do
       begin
        n:=n+1;
        slug:=slug+letter;
        letter:=GetCh(1);
       end;
      if n>LongName then error(7);
      Locate(slug,Local,n);
      c:=QTCh^[n].c;
      t:=QTCh^[n].t;
     end;
    32,9,10,13,123: { pазделитель+коментаpии }
     begin
      c:=0; n:=0; t:=0;
      while ((letter=#13) or (letter=#10) or
             (letter=#32) or (letter=#9) or
                             (letter=#123)) do
       begin
        while ((letter=#13) or
               (letter=#10) or
               (letter=#32) or
               (letter=#9)) do letter:=GetCh(1);
        if letter='{' then
         begin
          while (letter<>'}') do letter:=GetCh(1);
          letter:=GetCh(1);
         end;
       end;
     end;
    46:begin {"." - спец.символ}
        c:=5; t:=1; n:=0;
        letter:=GetCh(1);
       end;
    59:begin {";" - спец.символ}
        c:=5; t:=2; n:=0;
        letter:=GetCh(1);
       end;
    58:begin {":" - спец.символ}
        c:=5; t:=3; n:=0;
        letter:=GetCh(1);
       end;
    39:begin {"'" - спец.символ}
        c:=5; t:=4; n:=0;
        letter:=GetCh(1);
       end;
    61:begin {"=" - спец.символ}
        c:=5; t:=5; n:=0;
        letter:=GetCh(1);
       end;
    40:begin {"(" - спец.символ}
        c:=5; t:=6; n:=0;
        letter:=GetCh(1);
       end;
    41:begin {")" - спец.символ}
        c:=5; t:=7; n:=0;
        letter:=GetCh(1);
       end;
    62:begin {">" - спец.символ}
        c:=5; t:=8; n:=0;
        letter:=GetCh(1);
       end;
    60:begin {"<" - спец.символ}
        c:=5; t:=9; n:=0;
        letter:=GetCh(1);
       end;
    42:begin {"*" - спец.символ}
        c:=5; t:=10; n:=0;
        letter:=GetCh(1);
       end;
    91:begin {"[" - спец.символ}
        c:=5; t:=11; n:=0;
        letter:=GetCh(1);
       end;
    93:begin {"]" - спец.символ}
        c:=5; t:=12; n:=0;
        letter:=GetCh(1);
       end;
    43:begin {"+" - спец.символ}
        c:=5; t:=13; n:=0;
        letter:=GetCh(1);
       end;
    45:begin {"-" - спец.символ}
        c:=5; t:=14; n:=0;
        letter:=GetCh(1);
       end;
    44:begin {"," - спец.символ}
        c:=5; t:=15; n:=0;
        letter:=GetCh(1);
       end;
    47:begin {"/" - спец.символ}
        c:=5; t:=16; n:=0;
        letter:=GetCh(1);
       end;
    else error(6);
   end;
  end;
{===========================================================}
 Procedure EXE; { pазбоp }
  var
   cc,tt:byte;
   nn:word;
  procedure Header;                                 Forward;
  procedure Block;                                  Forward;
  procedure Declaration;                            Forward;
  procedure Complex;                                Forward;
  procedure TpVars(var lt,at,mt:word;var tt0:byte); Forward;
  procedure Operator;                               Forward;
  procedure Nam2Tp(var t:byte);                     Forward;
  procedure Sign(t:byte);                           Forward;
  procedure Augend(t:byte);                         Forward;
  procedure Factor(t:byte);                         Forward;
  procedure Digit(t:byte);                          Forward;
  procedure BEGIN0;                                 Forward;
  procedure END0;                                   Forward;
  procedure fcs(b:byte);                            Forward;
  procedure fcsw(w:word);                           Forward;
{╔════════════════════════════════════════════════════════╗}
  procedure fcs(b:byte);
   begin
    cs^[cs0]:=b;
    if cs0>=$FFFF then error(32);
    cs0:=cs0+1;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure fcsw(w:word);
   var l1,l2:longint;
   begin
    l1:=w;
    l2:=(l1 mod $100);
    cs^[cs0]:=l2;
    l1:=w;
    l2:=(l1 div $100);
    cs^[cs0+1]:=l2;
    if cs0>=$FFEF then error(32);
    cs0:=cs0+2;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure BEGIN0;
   var
    bbbb:byte;
   begin
    ds0:=256;  { sis-string }
    fcs($1E);  { push ax; ax=0; push ax; ax=ds..; ds=.. }
    fcs($2B);
    fcs($C0);
    fcs($50);
    fcs($B8);
    fcs($00);
    fcs($00);
    fcs($8E);
    fcs($D8);

    fcs($89);  { mov ax,sp }
    fcs($e0);
    fcs($2e);  { mov cs:[...],ax }
    fcs($a3);
    fcs($4b);
    fcs($00);
    fcs($eb);  { jmp }
    fcs($3d);
    LnCst:=' Overflow ordinal or integer variable   ';
    for bbbb:=1 to ord(LnCst[0]) do fcs(ord(LnCst[bbbb]));
    fcs($8C);        { mov ax,cs }
    fcs($C8);
    fcs($8E);        { mov ds,ax }
    fcs($d8);
    fcs($ba);     { mov dx,const }
    fcs($11);
    fcs($00);
    fcs($B9);         { mov cx,40}
    fcs($28);
    fcs($00);
    fcs($B4);        { mov ax,40h}
    fcs($40);
    fcs($BB);          { mov bx,1}
    fcs(1);
    fcs(0);
    fcs($CD);           { int 21h}
    fcs($21);
    fcs($bc);  { mov sp,const!!! }
    fcs($AA);
    fcs($AA);
    fcs($CB);           { ret far}
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure END0;
   begin
    fcs($CB);       { RET far}
    if (cs0 mod 16)>0 then cs0:=cs0+(16-(cs0 mod 16));
    if (ds0 mod 16)>0 then ds0:=ds0+(16-(ds0 mod 16));
    if (ss0 mod 16)>0 then ss0:=ss0+(16-(ss0 mod 16));
    Banner.m0:=$5A4D;                       { 00 }
    Banner.byt:=(cs0+ds0+ss0) mod 512;
    Banner.blok:=((cs0+ds0+ss0) div 512)+2;
    Banner.nel:=1;                          { 06 }
    Banner.rs:=$20;                         { 08 }
    Banner.cp:=0;                           { 0a }
    Banner.hl:=$FFFF;                       { 0c }
    Banner.ss:=(cs0+ds0) div 16;            { 0e }
    Banner.sp:=ss0;
    Banner.sum:=0;                          { 12 }
    Banner.ip:=0;
    Banner.cs:=0;                           { 16 }
    Banner.el1:=$1E;
    Banner.over:=0;
    Banner.tabl[1].sm:=5;                   { 1e }
    Banner.tabl[1].zn:=0;
    cs^[5]:=((cs0 div 16) mod $FF);
    cs^[6]:=((cs0 div 16) div $FF);
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Header;
   begin
    if cc=0 then skan(cc,tt,nn);              { пpобел }
    if (cc=1) and (nn=10) then               { 'program' }
    begin
     skan(cc,tt,nn);
     if cc<>0 then error(11);                 { пpобел }
     skan(cc,tt,nn);
     if cc<>2 then error(12);                    { имя }
     QTCh^[nn].c:=13;
     skan(cc,tt,nn);
     if (cc<>5) or (tt<>2) then error(13);            { ;}
     skan(cc,tt,nn);
    end;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Block;
   begin
    if cc=0 then skan(cc,tt,nn);  { пpобел }
    if (cc=1) and (nn=11) then       { 'var' }
     begin
      Declaration;
     end;
    Complex;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Declaration;
   var
    mo:array[1..50] of word;
    cno,no:byte;
    lo,ao:word;
    tp:byte;
    massa:word;
   begin
    skan(cc,tt,nn);
    if cc=0 then skan(cc,tt,nn);          { пpобел }
    repeat
     if cc<>2 then error(16);                { имя }
     no:=1;
     mo[no]:=nn;
     skan(cc,tt,nn);
     if cc=0 then skan(cc,tt,nn);         { пpобел }
     while ((cc=5) and (tt=15)) do               { , }
      begin
       skan(cc,tt,nn);
       if cc=0 then skan(cc,tt,nn);       { пpобел }
       if cc<>2 then error(16);              { имя }
       no:=no+1;
       if no>50 then error(23);
       mo[no]:=nn;
       skan(cc,tt,nn);
       if cc=0 then skan(cc,tt,nn);       { пpобел }
      end;
     if ((cc<>5) or (tt<>3)) then error(15);     { : }
     skan(cc,tt,nn);
     TpVars(lo,ao,massa,tp);
     if cc=0 then skan(cc,tt,nn);         { пpобел }
     if ((cc<>5) or (tt<>2)) then error(13);     { ; }
     skan(cc,tt,nn);
     if cc=0 then skan(cc,tt,nn);         { пpобел }
     for cno:=1 to no do
      begin
       QTCh^[mo[cno]].adr:=ds0;
       QTCh^[mo[cno]].Local:=lo;
       QTCh^[mo[cno]].t:=tp;
       QTCh^[mo[cno]].seg:=1;
       QTCh^[mo[cno]].c:=3;
       if ds0+massa>$FFFF then error(24);
       ds0:=ds0+massa;
      end;
    until ((cc=1) and (nn=12));             { 'begin' }
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure TpVars(var lt,at,mt:word;var tt0:byte);
   var
    ykt:word;
    ltt,mtt,att:word;
    ttt:byte;
    mot:array[1..50] of word;
    cnot,tpt:byte;
    q:byte;
    itip,itip0,itip1,itip2:longint;
   begin
    if cc=0 then skan(cc,tt,nn);     { пpобел }
    if cc<>1 then error(17);
    q:=nn;
    case q of
     26:begin  { <-<-<- byte }
         skan(cc,tt,nn);
         mt:=1;
         tt0:=1;
        end;
     27:begin  { <-<-<- integer }
         skan(cc,tt,nn);
         mt:=2;
         tt0:=2;
        end;
     28:begin  { <-<-<- Word }
         skan(cc,tt,nn);
         mt:=2;
         tt0:=3;
        end;
     29:begin  { <-<-<- boolean }
         skan(cc,tt,nn);
         mt:=1;
         tt0:=4;
        end;
     30:begin  { <-<-<- record }
         tt0:=5;
         ShowTCh:=ShowTCh+1;
         Local:=ShowTCh;
         lt:=ShowTCh;
         QTCh^[lt].b:=0;
         QTCh^[lt].m:=0;
         QTCh^[lt].TermName:='END';
         QTCh^[lt].c:=1;
         QTCh^[lt].t:=0;
         mt:=0;
         skan(cc,tt,nn);
         if cc=0 then skan(cc,tt,nn);          { пpобел }
         repeat
          if cc<>2 then error(16);                { имя }
          tpt:=1;
          mot[tpt]:=nn;
          skan(cc,tt,nn);
          if cc=0 then skan(cc,tt,nn);         { пpобел }
          while ((cc=5) and (tt=15)) do               { , }
           begin
            skan(cc,tt,nn);
            if cc=0 then skan(cc,tt,nn);       { пpобел }
            if cc<>2 then error(16);              { имя }
            tpt:=tpt+1;
            if tpt>50 then error(23);
            mot[tpt]:=nn;
            skan(cc,tt,nn);
            if cc=0 then skan(cc,tt,nn);       { пpобел }
           end;
          if ((cc<>5) or (tt<>3)) then error(15);     { : }
          Local:=0;
          skan(cc,tt,nn);
          TpVars(ltt,att,mtt,ttt);
          for cnot:=1 to tpt do
           begin
            QTCh^[mot[cnot]].adr:=mt;
            QTCh^[mot[cnot]].Local:=ltt;
            QTCh^[mot[cnot]].t:=ttt;
            QTCh^[mot[cnot]].seg:=1;
            QTCh^[mot[cnot]].c:=3;
            itip1:=mtt;
            itip2:=mt;
            itip:=itip1+itip2;
            itip0:=65536-ds0;
            if (itip>itip0) then
             begin
              error(24);
             end;
            mt:=mt+mtt;
          end;
          Local:=lt;
          if cc=0 then skan(cc,tt,nn);         { пpобел }
          if ((cc<>5) or (tt<>2)) then error(13);     { ; }
          skan(cc,tt,nn);
          if cc=0 then skan(cc,tt,nn);         { пpобел }
         until ((cc=1) and (nn=lt));              { 'end' }
         Local:=0;
         skan(cc,tt,nn);
        end;
     31:begin { <-<-<- char }
         skan(cc,tt,nn);
         mt:=1;
         tt0:=6;
        end;
     32:begin { <-<-<- string }
         skan(cc,tt,nn);
         mt:=256;
         tt0:=7;
        end;
     33:begin { <-<-<- array }
         skan(cc,tt,nn);
         if cc=0 then skan(cc,tt,nn);          { пpобел }
         if (cc<>5) or (tt<>11) then error(18);       { [ }
         skan(cc,tt,nn);
         if cc=0 then skan(cc,tt,nn);          { пpобел }
         lt:=ShowTCh+1;
         at:=1;
         tt0:=8;
         if cc<>7 then error(20);             { integer }
         if DigCst>$FFFF then error(21);
         mt:=DigCst;
         ShowTCh:=ShowTCh+1;
         QTCh^[ShowTCh].adr:=1;
         QTCh^[ShowTCh].t:=9;
         QTCh^[ShowTCh].Local:=ShowTCh+1;
         QTCh^[ShowTCh].c:=3;
         QTCh^[ShowTCh].TermName:='massiv';
         tpt:=1;
         mot[tpt]:=ShowTCh;
         skan(cc,tt,nn);
         if cc=0 then skan(cc,tt,nn);          { пpобел }
         while ((cc=5) and (tt=15)) do                { , }
          begin
           skan(cc,tt,nn);
           if cc=0 then skan(cc,tt,nn);        { пpобел }
           if cc<>7 then error(20);           { integer }
           if DigCst>65536 then error(21);
           itip1:=DigCst;
           itip2:=mt;
           itip:=itip1*itip2;
           itip0:=$FFFF;
           if (itip)>(itip0) then error(24);
           mt:=mt*DigCst;
           for cnot:=1 to tpt do
            QTCh^[mot[cnot]].adr:=QTCh^[mot[cnot]].adr*digcst;
           ShowTCh:=ShowTCh+1;
           QTCh^[ShowTCh].adr:=1;
           QTCh^[ShowTCh].t:=9;
           QTCh^[ShowTCh].Local:=ShowTCh+1;
           QTCh^[ShowTCh].c:=3;
           QTCh^[ShowTCh].TermName:='massiv';
           tpt:=tpt+1;
           mot[tpt]:=ShowTCh;
           skan(cc,tt,nn);
           if cc=0 then skan(cc,tt,nn);        { пpобел }
          end;
         if (cc<>5) or (tt<>12) then error(19);       { ] }
         skan(cc,tt,nn);
         if cc=0 then skan(cc,tt,nn);          { пpобел }
         if ((cc<>1) or (nn<>22)) then error(22);  { 'of' }
         skan(cc,tt,nn);
         if cc=0 then skan(cc,tt,nn);          { пpобел }
         ShowTCh:=ShowTCh+1;
         ykt:=ShowTCh;
         TpVars(ltt,att,mtt,ttt);
         QTCh^[ykt].adr:=0;
         QTCh^[ykt].Local:=ltt;
         QTCh^[ykt].t:=ttt;
         QTCh^[ykt].seg:=1;
         QTCh^[ykt].c:=3;
         QTCh^[ykt].TermName:='massiv0';
         itip1:=mtt;
         itip2:=mt;
         itip:=itip1*itip2;
         itip0:=$FFFF;
         if (itip)>(itip0) then error(23);
         mt:=mt*mtt;
         for cnot:=1 to tpt do
          QTCh^[mot[cnot]].adr:=QTCh^[mot[cnot]].adr*mtt;
        end;
     else error(17);
    end;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Complex;
   begin
    if ((cc<>1) or (nn<>12)) then error(16);      {'begin'}
    skan(cc,tt,nn);
    if cc=0 then skan(cc,tt,nn);               { пpобел }
    while not((cc=1) and (nn=13)) do                {'end'}
     begin
      Operator;
      if cc=0 then skan(cc,tt,nn);             { пpобел }
      if ((cc<>5) or (tt<>2)) then error(13);         { ; }
      skan(cc,tt,nn);
      if cc=0 then skan(cc,tt,nn);             { пpобел }
     end;
    skan(cc,tt,nn);
   end;
  {╠════════════════════════════════════════════════════════╣}
  procedure Operator;
   var
    tz:byte;
    zw,zv:word;
   begin
    if (cc<>1) and (cc<>3) then error(33);
    case cc of
     1:begin
        case nn of
    {.....}
         12:begin     { BEGIN }
             Complex;
            end;
    {.....}
         03:begin     { INSERT }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34);     { ( }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             Nam2Tp(tz);
             if tz<>7 then error(30);
             fcs($57);                            { push di }
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             if (cc<>5) or (tt<>15) then error(14);     { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             Sign(7);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             if (cc<>5) or (tt<>15) then error(14);     { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             Sign(1);
             fcs($5f);      { pop di }
             fcs($BB);      { mov bx,0 }
             fcs($00);
             fcs($00);
             fcs($b4);      { mov ah,0 }
             fcs($00);
             fcs($8a);      { mov bl,[di] }
             fcs($1d);
             fcs($89);      { mov si,bx }
             fcs($de);
             fcs($8a);      { mov bl,[00] }
             fcs($1e);
             fcs($00);
             fcs($00);
             fcs($01);      { add si,bx }
             fcs($de);
             fcs($81);      { cmp si,255 }
             fcs($fe);
             fcs($ff);
             fcs($00);
             fcs($72);      { jb }
             fcs($03);
             fcs($be);      { mov si,255 }
             fcs($ff);
             fcs($00);
             fcs($53);     { push bx }
             fcs($89);   { mov bx,si }
             fcs($f3);
             fcs($88); { mov [di],bl }
             fcs($1d);
             fcs($5b);      { pop bx }
             fcs($01);   { add si,di }
             fcs($fe);
             fcs($89);   { mov dx,di }
             fcs($fa);
             fcs($01);   { add dx,ax }
             fcs($c2);
             fcs($89);   { mov di,si }
             fcs($f7);
             fcs($29);   { sub di,bx }
             fcs($df);
             fcs($39);   { cmp dx,di }
             fcs($fa);
             fcs($77);          { ja }
             fcs($08);
             fcs($8a); { mov cl,[di] }
             fcs($0d);
             fcs($88); { mov [si],cl }
             fcs($0c);
             fcs($4e);      { dec si }
             fcs($4f);      { dec di }
             fcs($eb);         { jmp }
             fcs($f4);
             fcs($89);   { mov di,dx }
             fcs($d7);
             fcs($01);   { add dx,bx }
             fcs($da);
             fcs($be);  { mov si,001 }
             fcs($01);
             fcs($00);
             fcs($47);      { inc di }
             fcs($39);   { cmp dx,di }
             fcs($fa);
             fcs($72);          { jb }
             fcs($08);
             fcs($8a); { mov cl,[si] }
             fcs($0c);
             fcs($88); { mov [di],cl }
             fcs($0d);
             fcs($46);      { inc si }
             fcs($47);      { inc di }
             fcs($eb);         { jmp }
             fcs($f4);
             if ((cc<>5) or (tt<>7))then error(35); { ) }
             skan(cc,tt,nn);
            end;
    {.....}
         04:begin     { DELETE }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34);      { ( }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Nam2Tp(tz);
             if tz<>7 then error(30);
             fcs($57);                            { push di }
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if (cc<>5) or (tt<>15) then error(14);      { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Sign(1);
             fcs($89);                            { mov bx,ax }
             fcs($c3);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if (cc<>5) or (tt<>15) then error(14);      { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Sign(1);
             fcs($5f);   { pop di }
             fcs($b5);   { mov ch,00 }
             fcs($00);
             fcs($b4);   { mov ah,00 }
             fcs($00);
             fcs($b7);   { mov bh,00 }
             fcs($00);
             fcs($88);   { mov cl,al }
             fcs($c1);
             fcs($00);   { add cl,bl }
             fcs($d9);
             fcs($38); { cmp [di],cl }
             fcs($0d);
             fcs($77);          { ja }
             fcs($06);
             fcs($88); { mov [di],bl }
             fcs($1d);
             fcs($fe);  { dec b/[di] }
             fcs($0d);
             fcs($eb);         { jmp }
             fcs($02);
             fcs($28); { sub [di],al }
             fcs($05);
             fcs($8a); { mov al,[di] }
             fcs($05);
             fcs($01);   { add ax,di }
             fcs($f8);
             fcs($50);     { push ax }
             fcs($89);   { mov dx,di }
             fcs($fa);
             fcs($89);   { mov si,di }
             fcs($fe);
             fcs($01);   { add dx,cx }
             fcs($ca);
             fcs($89);   { mov di,dx }
             fcs($d7);
             fcs($01);   { add si,bx }
             fcs($de);
             fcs($5a);     { pop  dx }
             fcs($39);   { cmp si,dx }
             fcs($d6);
             fcs($77);          { ja }
             fcs($08);
             fcs($8a); { mov cl,[di] }
             fcs($0d);
             fcs($88); { mov [si],cl }
             fcs($0c);
             fcs($46);      { inc si }
             fcs($47);      { inc di }
             fcs($eb);         { jmp }
             fcs($f4);
             if ((cc<>5) or (tt<>7))then error(35); { ) }
             skan(cc,tt,nn);
            end;
    {.....}
         07:begin     { COPY }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34);      { ( }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Nam2Tp(tz);
             fcs($57);                            { push di }
             if tz<>7 then error(30);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if (cc<>5) or (tt<>15) then error(14);      { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Sign(7);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if (cc<>5) or (tt<>15) then error(14);      { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Sign(1);
             fcs($89);                             { mov bx,ax }
             fcs($c3);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if (cc<>5) or (tt<>15) then error(14);  { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);  { пpобел }
             Sign(1);
             fcs($b4);   { mov ah,00 }
             fcs($00);
             fcs($b7);   { mov bh,00 }
             fcs($00);
             fcs($1E);     { push ds }
             fcs($07);      { pop es }
             fcs($89);   { mov si,bx }
             fcs($de);
             fcs($5f);      { pop di }
             fcs($88); { mov [di],al }
             fcs($05);
             fcs($47);      { inc di }
             fcs($89);   { mov cx,ax }
             fcs($c1);
             fcs($FC);         { cld }
             fcs($F3);   { rep movsb }
             fcs($A4);
             if ((cc<>5) or (tt<>7))then error(35);  { ) }
             skan(cc,tt,nn);
            end;
    {.....}
         06:begin     { LENGTH }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34);      { ( }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Sign(7);
             fcs($50);                            { push ax }
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             if (cc<>5) or (tt<>15) then error(14);      { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             Nam2Tp(tz);
             if tz<>1 then error(30);
             if cc=0 then skan(cc,tt,nn);          { пpобел }
             fcs($58); { pop ax }
             fcs($a0); { mov al,[00] }
             fcs($00);
             fcs($00);
             fcs($88); { mov [di],al }
             fcs($05);
             if ((cc<>5) or (tt<>7))then error(35); { ) }
             skan(cc,tt,nn);
            end;
    {.....}
         08:begin     { Ch2Dig }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);           { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34);       { ( }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);           { пpобел }
             Sign(6);
             fcs($50);                             { push ax }
             if cc=0 then skan(cc,tt,nn);           { пpобел }
             if (cc<>5) or (tt<>15) then error(14);       { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);           { пpобел }
             Nam2Tp(tz);
             if tz<>1 then error(30);
             if cc=0 then skan(cc,tt,nn);           { пpобел }
             fcs($58);      { pop ax }
             fcs($88); { mov [di],al }
             fcs($05);
             if ((cc<>5) or (tt<>7))then error(35); { ) }
             skan(cc,tt,nn);
            end;
    {.....}
         14:begin     { IF }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);  { пpобел }
             Sign(4);
             fcs($3c); { cmp al,01 }
             fcs($01);
             fcs($74);         { jz }
             fcs($03);
             fcs($e9);       { jmp }
             zw:=cs0;
             fcs($00);
             fcs($00);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             if (cc<>1) or (nn<>15) then error(42);
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             Operator;
             fcs($e9);                               { jmp }
             fcs($00);
             fcs($00);
             cs^[zw]:=((cs0-zw-2) mod $100);
             cs^[zw+1]:=((cs0-zw-2) div $100);
             zw:=cs0-2;
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             if (cc=1) and (nn=16) then               { else }
              begin
               skan(cc,tt,nn);
               if cc=0 then skan(cc,tt,nn);       { пpобел }
               Operator;
               cs^[zw]:=((cs0-zw-2) mod $100);
               cs^[zw+1]:=((cs0-zw-2) div $100);
              end;
             if cc=0 then skan(cc,tt,nn);         { пpобел }
            end;
    {.....}
         17:begin     { FOR }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             Nam2Tp(tz);
             fcs($57);                           { push di }
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             if (cc<>5) or (tt<>3) then error(38);       { : }
             skan(cc,tt,nn);
             if (cc<>5) or (tt<>5) then error(38);       { = }
             skan(cc,tt,nn);
             case tz of
              1:begin  { byte }
                 Sign(1);
                 fcs($b4); { mov ah,00 }
                 fcs($00);
                 fcs($50);   { push ax }
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 if (cc<>1) or (nn<>18) then error(43);
                 skan(cc,tt,nn);
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 Sign(1);
                 fcs($5b);     { pop bx }
                 fcs($b4);  { mov ah,00 }
                 fcs($00);
                 fcs($5f);     { pop di }
                 fcs($89); { mov[di],bx }
                 fcs($1d);
                 fcs($50);    { push ax }
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 if (cc<>1) or ((nn<>19) and (nn<>20))
                   then error(44);
                 if nn=19 then
                  begin
                   skan(cc,tt,nn);
                   if cc=0 then skan(cc,tt,nn); { пpобел }
                   fcs($fe);    { dec [di] }
                   fcs($0d);
                   zw:=cs0;
                   fcs($58);      { pop ax }
                   fcs($50);     { push ax }
                   fcs($38); { cmp [di],al }
                   fcs($05);
                   fcs($75);        { jne+3}
                   fcs($03);
                   fcs($e9);        { jmp  }
                   zv:=cs0;
                   fcs($00);
                   fcs($00);
                   fcs($fe);    { inc [di] }
                   fcs($05);
                   fcs($57);     { push di }
                   Operator;
                   fcs($5f);      { pop di }
                   fcs($e9);        { jmp  }
                   fcsw(zw-cs0-2);
                   cs^[zv]:=((cs0-zv-2) mod $100);
                   cs^[zv+1]:=((cs0-zv-2) div $100);
                   fcs($58);      { pop ax }
                  end;
                if nn=20 then
                 begin
                   skan(cc,tt,nn);
                   if cc=0 then skan(cc,tt,nn); { пpобел }
                   fcs($fe);    { inc [di] }
                   fcs($05);
                   zw:=cs0;
                   fcs($58);      { pop ax }
                   fcs($50);     { push ax }
                   fcs($38); { cmp [di],al }
                   fcs($05);
                   fcs($75);        { jne+3}
                   fcs($03);
                   fcs($e9);        { jmp  }
                   zv:=cs0;
                   fcs($00);
                   fcs($00);
                   fcs($fe);    { dec [di] }
                   fcs($0d);
                   fcs($57);     { push di }
                   Operator;
                   fcs($5f);      { pop di }
                   fcs($e9);        { jmp  }
                   fcsw(zw-cs0-2);
                   cs^[zv]:=((cs0-zv-2) mod $100);
                   cs^[zv+1]:=((cs0-zv-2) div $100);
                   fcs($58);      { pop ax }
                 end;
                end;
              2:begin  { integer }
                 Sign(2);
                 fcs($50);       { push ax }
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 if (cc<>1) or (nn<>18) then error(43);
                 skan(cc,tt,nn);
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 Sign(2);
                 fcs($5b);     { pop bx }
                 fcs($5f);     { pop di }
                 fcs($89); { mov[di],bx }
                 fcs($1d);
                 fcs($50);    { push ax }
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 if (cc<>1) or ((nn<>19) and (nn<>20))
                   then error(44);
                 if nn=19 then
                  begin
                   skan(cc,tt,nn);
                   if cc=0 then skan(cc,tt,nn); { пpобел }
                   fcs($ff);    { dec [di] }
                   fcs($0d);
                   zw:=cs0;
                   fcs($58);      { pop ax }
                   fcs($50);     { push ax }
                   fcs($38); { cmp [di],al }
                   fcs($05);
                   fcs($75);        { jne+3}
                   fcs($03);
                   fcs($e9);        { jmp  }
                   zv:=cs0;
                   fcs($00);
                   fcs($00);
                   fcs($ff);    { inc [di] }
                   fcs($05);
                   fcs($57);     { push di }
                   Operator;
                   fcs($5f);      { pop di }
                   fcs($e9);        { jmp  }
                   fcsw(zw-cs0-2);
                   cs^[zv]:=((cs0-zv-2) mod $100);
                   cs^[zv+1]:=((cs0-zv-2) div $100);
                   fcs($58);      { pop ax }
                  end;
                if nn=20 then
                 begin
                   skan(cc,tt,nn);
                   if cc=0 then skan(cc,tt,nn); { пpобел }
                   fcs($ff);    { inc [di] }
                   fcs($05);
                   zw:=cs0;
                   fcs($58);      { pop ax }
                   fcs($50);     { push ax }
                   fcs($38); { cmp [di],al }
                   fcs($05);
                   fcs($75);        { jne+3}
                   fcs($03);
                   fcs($e9);        { jmp  }
                   zv:=cs0;
                   fcs($00);
                   fcs($00);
                   fcs($ff);    { dec [di] }
                   fcs($0d);
                   fcs($57);     { push di }
                   Operator;
                   fcs($5f);      { pop di }
                   fcs($e9);        { jmp  }
                   fcsw(zw-cs0-2);
                   cs^[zv]:=((cs0-zv-2) mod $100);
                   cs^[zv+1]:=((cs0-zv-2) div $100);
                   fcs($58);      { pop ax }
                 end;
                end;
              3:begin  { word }
                 Sign(3);
                 fcs($50);       { push ax }
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 if (cc<>1) or (nn<>18) then error(43);
                 skan(cc,tt,nn);
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 Sign(3);
                 fcs($5b);     { pop bx }
                 fcs($5f);     { pop di }
                 fcs($89); { mov[di],bx }
                 fcs($1d);
                 fcs($50);    { push ax }
                 if cc=0 then skan(cc,tt,nn); { пpобел }
                 if (cc<>1) or ((nn<>19) and (nn<>20))
                  then error(44);
                 if nn=19 then
                  begin
                   skan(cc,tt,nn);
                   if cc=0 then skan(cc,tt,nn); { пpобел }
                   fcs($ff);    { dec [di] }
                   fcs($0d);
                   zw:=cs0;
                   fcs($58);      { pop ax }
                   fcs($50);     { push ax }
                   fcs($38); { cmp [di],al }
                   fcs($05);
                   fcs($75);        { jne+3}
                   fcs($03);
                   fcs($e9);        { jmp  }
                   zv:=cs0;
                   fcs($00);
                   fcs($00);
                   fcs($ff);    { inc [di] }
                   fcs($05);
                   fcs($57);     { push di }
                   Operator;
                   fcs($5f);      { pop di }
                   fcs($e9);        { jmp  }
                   fcsw(zw-cs0-2);
                   cs^[zv]:=((cs0-zv-2) mod $100);
                   cs^[zv+1]:=((cs0-zv-2) div $100);
                   fcs($58);      { pop ax }
                  end;
                if nn=20 then
                 begin
                   skan(cc,tt,nn);
                   if cc=0 then skan(cc,tt,nn); { пpобел }
                   fcs($ff);    { inc [di] }
                   fcs($05);
                   zw:=cs0;
                   fcs($58);      { pop ax }
                   fcs($50);     { push ax }
                   fcs($38); { cmp [di],al }
                   fcs($05);
                   fcs($75);        { jne+3}
                   fcs($03);
                   fcs($e9);        { jmp  }
                   zv:=cs0;
                   fcs($00);
                   fcs($00);
                   fcs($ff);    { dec [di] }
                   fcs($0d);
                   fcs($57);     { push di }
                   Operator;
                   fcs($5f);      { pop di }
                   fcs($e9);        { jmp  }
                   fcsw(zw-cs0-2);
                   cs^[zv]:=((cs0-zv-2) mod $100);
                   cs^[zv+1]:=((cs0-zv-2) div $100);
                   fcs($58);      { pop ax }
                 end;
                end;
              else error(25);
             end;
            end;
    {.....}
         23:begin     { WHILE }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn); { пpобел }
             zv:=cs0;
             Sign(4);
             fcs($3c); { cmp al,01 }
             fcs($01);
             fcs($74);        { jz }
             fcs($03);
             fcs($e9);       { jmp }
             zw:=cs0;
             fcs($00);
             fcs($00);
             if cc=0 then skan(cc,tt,nn); { пpобел }
             if (cc<>1) or (nn<>24) then error(42);
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn); { пpобел }
             Operator;
             fcs($e9);      { jmp  }
             fcsw(zv-cs0-2);
             cs^[zw]:=((cs0-zw-2) mod $100);
             cs^[zw+1]:=((cs0-zw-2) div $100);
            end;
    {.....}
         09:begin     { Dig2Ch }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn); { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34); { ( }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn); { пpобел }
             Sign(1);
             fcs($50);                          { push ax }
             if cc=0 then skan(cc,tt,nn);        { пpобел }
             if (cc<>5) or (tt<>15) then error(14);    { , }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);        { пpобел }
             Nam2Tp(tz);
             if tz<>6 then error(30);
             if cc=0 then skan(cc,tt,nn);        { пpобел }
             fcs($58);                           { pop ax }
             fcs($88);                      { mov [di],al }
             fcs($05);
             if ((cc<>5) or (tt<>7))then error(35);     { ) }
             skan(cc,tt,nn);
            end;
    {.....}
         34:begin     { WRITE }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn);         { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34);     { ( }
             while not((cc=5) and (tt=7)) do             { ) }
              begin
               skan(cc,tt,nn);
               if cc=0 then skan(cc,tt,nn);       { пpобел }
               Sign(0);
               fcs($B4); { mov ax,40h}
               fcs($40);
               fcs($BB);   { mov bx,1}
               fcs(1);
               fcs(0);
               fcs($CD);    { int 21 }
               fcs($21);
               if cc=0 then skan(cc,tt,nn); { пpобел }
               if ((cc<>5) or ((tt<>7) and (tt<>15)))
                 then error(35);            { , ) }
               if cc=0 then skan(cc,tt,nn); { пpобел }
              end;
             skan(cc,tt,nn);
            end;
    {.....}
         05:begin      { WRITELN }
             skan(cc,tt,nn);
             fcs($BB);    { mov bx,0 }
             fcs($00);
             fcs($00);
             fcs($B8); { mov ax,0a0d }
             fcs($0D);
             fcs($0A);
             fcs($89); { mov [bx],ax }
             fcs($07);
             fcs($89);   { mov dx,bx }
             fcs($DA);
             fcs($B9);    { mov cx,2 }
             fcs($02);
             fcs($00);
             fcs($B4);  { mov ax,40h }
             fcs($40);
             fcs($BB);    { mov bx,1 }
             fcs($01);
             fcs($00);
             fcs($CD);      { int 21 }
             fcs($21);
            end;
    {.....}
         35:begin        { READ }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn); { пpобел }
             if ((cc<>5) or (tt<>6)) then error(34); { ( }
             skan(cc,tt,nn);
             if cc=0 then skan(cc,tt,nn); { пpобел }
             Nam2Tp(tz);
             fcs($57);     { push di }
             fcs($ba); { mov dx,0000 }
             fcs($00);
             fcs($00);
             fcs($b0);  { mov al,254 }
             fcs($fe);
             fcs($89);   { mov bx,dx }
             fcs($d3);
             fcs($88); { mov [bx],al }
             fcs($07);
             fcs($b4);  { mov ah,0ah }
             fcs($0a);
             fcs($cd);     { int 21h }
             fcs($21);
             case tz of
              1,2,3:begin        { byte,integer,word }
                     fcs($fe);        { inc b/[0001] }
                     fcs($06);
                     fcs($01);
                     fcs($00);
                     fcs($bb);            { mov bx,2 }
                     fcs($02);
                     fcs($00);
                     if tz=2 then
                      begin
                       fcs($b0);        { mov al,'+' }
                       fcs($2b);
                       fcs($38);        { cmp [2],al }
                       fcs($06);
                       fcs($02);
                       fcs($00);
                       fcs($75);             { jne + }
                       fcs($09);
                       fcs($bb);         { mov bx,03 }
                       fcs($03);
                       fcs($00);
                       fcs($b8);          { mov ax,0 }
                       fcs($00);
                       fcs($00);
                       fcs($50);           { push ax }
                       fcs($eb);             { jmp + }
                       fcs($15);
                       fcs($b0);        { mov al,'-' }
                       fcs($2d);
                       fcs($38);        { cmp [2],al }
                       fcs($06);
                       fcs($02);
                       fcs($00);
                       fcs($75);             { jne + }
                       fcs($09);
                       fcs($bb);         { mov bx,03 }
                       fcs($03);
                       fcs($00);
                       fcs($b8);          { mov ax,1 }
                       fcs($01);
                       fcs($00);
                       fcs($50);           { push ax }
                       fcs($eb);             { jmp + }
                       fcs($04);
                       fcs($b8);          { mov ax,0 }
                       fcs($00);
                       fcs($00);
                       fcs($50);           { push ax }
                      end;
                     fcs($b8);           { mov ax,00 }
                     fcs($00);
                     fcs($00);
                     fcs($3a);         { cmp bl,[01] }
                     fcs($1e);
                     fcs($01);
                     fcs($00);
                     fcs($7f);              { jg +29 }
                     fcs($1d);
                     fcs($b2);           { mov dl,'0'}
                     fcs($30);
                     fcs($38);         { cmp [bx],dl }
                     fcs($17);
                     fcs($7c);              { jl +23 }
                     fcs($17);
                     fcs($b2);           { mov dl,'9'}
                     fcs($39);
                     fcs($38);         { cmp [bx],dl }
                     fcs($17);
                     fcs($7f);              { jg +17 }
                     fcs($11);
                     fcs($8a);         { mov cl,[bx] }
                     fcs($0f);
                     fcs($80);          { sub cl,30h }
                     fcs($e9);
                     fcs($30);
                     fcs($43);              { inc bx }
                     fcs($bf);           { mov di,10 }
                     fcs($0a);
                     fcs($00);
                     fcs($f7);              { mul di }
                     fcs($e7);
                     fcs($b5);           { mov ch,00 }
                     fcs($00);
                     fcs($01);           { add ax,cx }
                     fcs($c8);
                     fcs($eb);             { jmp -31 }
                     fcs($dd);
                     if tz=2 then
                      begin
                       fcs($80);         { and ah,8f }
                       fcs($e4);
                       fcs($8f);
                       fcs($5b);            { pop bx }
                       fcs($80);          { cmp bl,0 }
                       fcs($fb);
                       fcs($00);
                       fcs($74);             { je +2 }
                       fcs($02);
                       fcs($f7);            { neg ax }
                       fcs($d8);
                      end;
                     fcs($5f);              { pop di }
                     if tz=1 then
                      begin
                       fcs($88);       { mov [di],al }
                       fcs($05);
                      end
                             else
                      begin
                       fcs($89);       { mov [di],ax }
                       fcs($05);
                      end;
                    end;
              6:begin                         { char }
                 fcs($5f);                  { pop di }
                 fcs($c6);             { mov [di],00 }
                 fcs($05);
                 fcs($00);
                 fcs($b0);                { mov al,0 }
                 fcs($00);
                 fcs($38);              { cmp [1],al }
                 fcs($06);
                 fcs($01);
                 fcs($00);
                 fcs($7c);                 { > jl +5 }
                 fcs($05);
                 fcs($a0);              { mov al,[2] }
                 fcs($02);
                 fcs($00);
                 fcs($88);             { mov [di],al }
                 fcs($05);
                end;
              7:begin                       { string }
                 fcs($1E);                 { push ds }
                 fcs($07);                  { pop es }
                 fcs($BE);               { mov si,.. }
                 fcsw(01);
                 fcs($5f);                  { pop di }
                 fcs($B9);              { mov cx,255 }
                 fcsw($100);
                 fcs($FC);                     { cld }
                 fcs($F3);               { rep movsb }
                 fcs($A4);
                end;
              else error(30);
             end;
             if cc=0 then skan(cc,tt,nn); { пpобел }
             if ((cc<>5) or (tt<>7)) then error(37); { ) }
             skan(cc,tt,nn);
             fcs($BB);    { mov bx,0 }
             fcs($00);
             fcs($00);
             fcs($B8); { mov ax,0a0d }
             fcs($0D);
             fcs($0A);
             fcs($89); { mov [bx],ax }
             fcs($07);
             fcs($89);   { mov dx,bx }
             fcs($DA);
             fcs($B9);    { mov cx,2 }
             fcs($02);
             fcs($00);
             fcs($B4);  { mov ax,40h }
             fcs($40);
             fcs($BB);    { mov bx,1 }
             fcs($01);
             fcs($00);
             fcs($CD);      { int 21 }
             fcs($21);
            end;
    {.....}
         else error(33);
        end;
       end;
     3:begin   { := }
        begin
         Nam2Tp(tz);
         fcs($57);                     { push di }
         if cc=0 then skan(cc,tt,nn);   { пpобел }
         if (cc<>5) or (tt<>3) then error(38); { : }
         skan(cc,tt,nn);
         if (cc<>5) or (tt<>5) then error(38); { = }
         skan(cc,tt,nn);
         case tz of
          1:begin              { byte }
             Sign(1);
             fcs($5f);       { pop di }
             fcs($88);  { mov [di],al }
             fcs($05);
            end;
          2:begin           { integer }
             Sign(2);
             fcs($5f);       { pop di }
             fcs($89);  { mov [di],ax }
             fcs($05);
            end;
          3:begin              { word }
             Sign(3);
             fcs($5f);       { pop di }
             fcs($89);  { mov [di],ax }
             fcs($05);
            end;
          4:begin           { boolean }
             Sign(4);
             fcs($5f);       { pop di }
             fcs($88);  { mov [di],al }
             fcs($05);
            end;
          6:begin              { char }
             Sign(6);
             fcs($5f);       { pop di }
             fcs($88);  { mov [di],al }
             fcs($05);
            end;
          7:begin            { string }
             Sign(7);
             fcs($1E);      { push ds }
             fcs($07);       { pop es }
             fcs($BE);    { mov si,.. }
             fcsw(00);
             fcs($5f);       { pop di }
             fcs($B9);   { mov cx,256 }
             fcsw($100);
             fcs($FC);          { cld }
             fcs($F3);    { rep movsb }
             fcs($A4);
            end;
          else error(30);
         end;
        end;
       end;
     else ;
    end;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Nam2Tp(var t:byte);
   var
    a0,a:word;
   begin
    if cc=0 then skan(cc,tt,nn);        { пpобел }
    if cc<>3 then error(25);
    case tt of
     1..4,6,7:begin
               t:=tt;
               a:=QTCh^[nn].adr;
               fcs($BF);        { mov di,const-a }
               fcsw(a);
               skan(cc,tt,nn);
              end;
     5:begin  { record }
        a:=QTCh^[nn].adr;
        fcs($BF);               { mov di,const-a }
        fcsw(a);
        Local:=QTCh^[nn].Local;
        skan(cc,tt,nn);
        if cc=0 then skan(cc,tt,nn);    { пpобел }
        if ((cc<>5) or (tt<>1)) then error(27); { . }
        skan(cc,tt,nn);
        if cc=0 then skan(cc,tt,nn);       { пpобел }
        if cc<>3 then error(12);     { имя=пеpемен. }
        fcs($57);    { push di }
        Nam2Tp(t);
        fcs($58);     { pop ax }
        fcs($01);  { add di,ax }
        fcs($C7);
        Local:=0;
       end;
     8:begin  { array }
        a:=QTCh^[nn].adr;
        a0:=nn;
        fcs($BF); { mov di,const-a }
        fcsw(a);
        skan(cc,tt,nn);
        if cc=0 then skan(cc,tt,nn); { пpобел }
        if (cc<>5) or (tt<>11) then error(18); { [ }
        repeat
         a0:=QTCh^[a0].Local;
         cc:=QTCh^[a0].c;
         tt:=QTCh^[a0].t;
         if (cc<>3) or (tt<>9)
           then error(28); { массив ли ? }
         a:=QTCh^[nn].adr;
         skan(cc,tt,nn);
         if cc=0 then skan(cc,tt,nn); { пpобел }
         Sign(3);  { word в ax }
         fcs($BB);  { mov bx,a }
         fcsw(a);
         fcs($57);   { push di }
         fcs($F7); { mul ax,bx }
         fcs($E3);
         fcs($5F);    { pop di }
         fcs($01); { add di,ax }
         fcs($C7);
         if cc=0 then skan(cc,tt,nn); { пpобел }
         if ((cc<>5) or ((tt<>12) and (tt<>15)))
           then error(14);  { , ] }
        until (cc=5) and (tt=12);
        a0:=QTCh^[a0].Local;
        cc:=QTCh^[a0].c;
        tt:=QTCh^[a0].t;
        nn:=a0;
        fcs($57);    { push di }
        Nam2Tp(t);
        fcs($58);     { pop ax }
        fcs($01);  { add di,ax }
        fcs($C7);
      end;
     else error(26);
    end;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Sign(t:byte);
   var
    iz:word;
    adressok:word;
    tz:byte;
    oper:boolean;
   begin
    if cc=0 then skan(cc,tt,nn); { пpобел }
    case t of
{------}
     0:begin
        case cc of
         8:begin                { const-str.}
            fcs($EB);             { jmp ... }
            fcs(ord(LnCst[0]));
            adressok:=cs0;
            for iz:=1 to ord(LnCst[0]) do
             fcs(ord(LnCst[iz]));
            fcs($1E);              { push ds }
            fcs($07);               { pop es }
            fcs($1E);              { push ds }
            fcs($8C);            { mov ax,cs }
            fcs($C8);
            fcs($8E);              {mov ds,ax}
            fcs($D8);
            fcs($BE);              {mov si,..}
            fcsw(adressok);
            fcs($BF);              {mov di,..}
            fcsw(0);
            fcs($B9);              {mov cx,..}
            fcsw(ord(LnCst[0]));
            fcs($FC);                  { cld }
            fcs($F3);              {rep movsb}
            fcs($A4);
            fcs($B9);              {mov cx,..}
            fcsw(ord(LnCst[0]));
            fcs($BA);              {mov dx,..}
            fcsw(0);
            fcs($1F);               { pop ds }
            skan(cc,tt,nn);
           end;
         3:begin                   { пеpемен.}
            Nam2Tp(tz);
            case tz of
             1,2,
               3,4:begin  { byte/word/integ !!!+boolean}
                    fcs($BB);         { mov bx,0}
                    fcsw(0);
                    case tz of
                     1,
                     4:begin             { byte }
                        fcs($B4);     { mov ah,0}
                        fcs(0);
                        fcs($8A); { mov al,[di] }
                        fcs($05);
                       end;
                     2:begin          { integer }
                        fcs($8B);   {mov ax,[di]}
                        fcs($05);
                        fcs($3D);     { cmp ax,0}
                        fcs($00);
                        fcs($00);
                        fcs($7D);        { jge  }
                        fcs($07);
                        fcs($F7);      { neg ax }
                        fcs($D8);
                        fcs($C6);   {mov [bx],2d}
                        fcs($07);
                        fcs($2D);
                        fcs($EB);       { jmp 3 }
                        fcs($03);
                        fcs($C6);   {mov [bx],2b}
                        fcs($07);
                        fcs($2B);
                        fcs($43);      { inc bx }
                       end;
                     3:begin             { word }
                        fcs($8B);   {mov ax,[di]}
                        fcs($05);
                       end;
                    end;              { перевод }
                    fcs($3D);         { cmp ax,0}
                    fcs($00);
                    fcs($00);
                    fcs($74);           { jz m1 }
                    fcs($16);
                    fcs($B9);      {mov cx,10000}
                    fcs($10);
                    fcs($27);
                    fcs($39);    { m2:cmp ax,cx }
                    fcs($C8);
                    fcs($73);          { jae m3 }
                    fcs($2E);
                    fcs($50);         { push ax }
                    fcs($89);         {mov ax,cx}
                    fcs($C8);
                    fcs($29);         {sub dx,dx}
                    fcs($D2);
                    fcs($B9);     { mov cx,000a }
                    fcs($0A);
                    fcs($00);
                    fcs($F7);          { div cx }
                    fcs($F1);
                    fcs($89);       { mov cx,ax }
                    fcs($C1);
                    fcs($58);          { pop ax }
                    fcs($EB);          { jmp m2 }
                    fcs($ED);
                    fcs($C6);     {m1:mov[bx],30h}
                    fcs($07);
                    fcs($30);
                    fcs($43);          { inc bx }
                    fcs($eb);          { jmp m5 }
                    fcs($24);
                    fcs($29);     {m3:sub dx,dx }
                    fcs($D2);
                    fcs($F7);          { div cx }
                    fcs($F1);
                    fcs($05);       { add ax,30h}
                    fcs($30);
                    fcs($00);
                    fcs($88);     { mov [bx],al }
                    fcs($07);
                    fcs($89);       { mov ax,dx }
                    fcs($D0);
                    fcs($50);         { push ax }
                    fcs($89);       { mov ax,cx }
                    fcs($C8);
                    fcs($29);       { sub dx,dx }
                    fcs($D2);
                    fcs($B9);     { mov cx,000a }
                    fcs($0A);
                    fcs($00);
                    fcs($F7);          { div cx }
                    fcs($F1);
                    fcs($89);       { mov cx,ax }
                    fcs($C1);
                    fcs($58);          { pop ax }
                    fcs($43);          { inc bx }
                    fcs($83);        { cmp cx,1 }
                    fcs($F9);
                    fcs($01);
                    fcs($75);           { jne m3}
                    fcs($E2);
                    fcs($05);     {m4:add ax,30h}
                    fcs($30);
                    fcs($00);
                    fcs($88);     { mov [bx],al }
                    fcs($07);
                    fcs($43);          { inc bx }
                    fcs($89);     {m5:mov cx,bx }
                    fcs($D9);
                   end;
             7:begin                   { string }
                fcs($89);           { mov dx,di }
                fcs($FA);
                fcs($89);           { mov bx,dx }
                fcs($D3);
                fcs($B5);           { mov ch,00 }
                fcs($00);
                fcs($8A);         { mov cl,[bx] }
                fcs($0F);
                fcs($42);              { inc dx }
               end;
             6:begin                     { char }
                fcs($89);           { mov dx,di }
                fcs($FA);
                fcs($B9);            { mov cx,1 }
                fcs($01);
                fcs($00);
               end;
             else error(36);
            end;
           end;
         else error(31);
        end;
       end;
{------}
     1:begin  { byte }
        Augend(t);
        if cc=0 then skan(cc,tt,nn);      { пpобел }
        while (cc=5) and
              ((tt=13) or (tt=14)) do     { + - }
         begin
          oper:=tt=13;                         { + }
          fcs($50);                      { push ax }
          skan(cc,tt,nn);
          Augend(t);
          fcs($5B);                       { pop bx }
          if oper then
           begin
            fcs($00);                  { add al,bl }
            fcs($d8);
            fcs($73);                     { jnc +3 }
            fcs($03);
            fcs($e9);                  { jmp error }
            fcsw($39-cs0-2);
           end
                  else
           begin
            fcs($28);                  { sub bl,al }
            fcs($c3);
            fcs($89);                  { mov ax,bx }
            fcs($d8);
           end;
          if cc=0 then skan(cc,tt,nn);    { пpобел }
         end;
       end;
{------}
         2:begin   { integer }
            Augend(t);
            if cc=0 then skan(cc,tt,nn);   { пpобел }
            while (cc=5) and
                  ((tt=13) or (tt=14)) do  { + - }
             begin
              oper:=tt=13;                      { + }
              fcs($50);                   { push ax }
              skan(cc,tt,nn);
              Augend(t);
              if oper then
               begin
                fcs($5B);           { pop bx }
                fcs($01);        { add ax,bx }
                fcs($d8);
                fcs($71);           { jno +3 }
                fcs($03);
                fcs($e9);        { jmp error }
                fcsw($39-cs0-2);
               end
                      else
               begin
                fcs($89);        { mov bx,ax }
                fcs($c3);
                fcs($58);           { pop ax }
                fcs($29);        { sub ax,bx }
                fcs($d8);
                fcs($71);           { jno +3 }
                fcs($03);
                fcs($e9);        { jmp error }
                fcsw($39-cs0-2);
               end;
              if cc=0 then skan(cc,tt,nn); { пpобел }
             end;
       end;
{------}
     3:begin  { word }
        Augend(t);
        if cc=0 then skan(cc,tt,nn);  { пpобел }
        while (cc=5) and ((tt=13) or (tt=14)) do  { + - }
         begin
          oper:=tt=13;              { + }
          fcs($50);           { push ax }
          skan(cc,tt,nn);
          Augend(t);
          fcs($5B);            { pop bx }
          if oper then
           begin
            fcs($01);       { add ax,bx }
            fcs($d8);
            fcs($73);          { jnc +3 }
            fcs($03);
            fcs($e9);       { jmp error }
            fcsw($39-cs0-2);
           end
                  else
           begin
            fcs($29);       { sub ax,bx }
            fcs($c3);
            fcs($89);       { mov ax,bx }
            fcs($d8);
           end;
          if cc=0 then skan(cc,tt,nn); { пpобел }
         end;
   end;
{------}
     4:begin  { boolean }
        Augend(t);
        if cc=0 then skan(cc,tt,nn);  { пpобел }
        while (cc=1) and (nn=37) do         { or }
         begin
          fcs($50);                  { push ax }
          skan(cc,tt,nn);
          Augend(t);
          fcs($5B);                   { pop bx }
          fcs($08);                 { or al,bl }
          fcs($d8);
          if cc=0 then skan(cc,tt,nn); { пpобел }
         end;
       end;
{------}
     6:begin  { char }
        case cc of
         8:begin      { const }
            if ord(LnCst[0])<>1 then error(39);
            fcs($b0);           { mov al,const }
            fcs(ord(LnCst[1]));
            skan(cc,tt,nn);
           end;
         3:begin
            Nam2Tp(tz);
            case tz of
             6:begin    { char }
                fcs($8a);        { mov al,[di] }
                fcs($05);
               end;
             7:begin    { string }
                if cc=0 then skan(cc,tt,nn); { пpобел }
                if (cc<>5) or (tt<>11) then error(18); { [ }
                skan(cc,tt,nn);
                fcs($57);     { push di }
                Sign(1);
                fcs($5f);      { pop di }
                fcs($b4);    { mov ah,0 }
                fcs($00);
                fcs($01);   { add di,ax }
                fcs($c7);
                fcs($8a); { mov al,[di] }
                fcs($05);
                if cc=0 then skan(cc,tt,nn); { пpобел }
                if (cc<>5) or (tt<>12) then error(19); { ] }
                skan(cc,tt,nn);
               end;
             else error(30);
            end;
           end;
         else error(30);
        end;
       end;
{------}
     7:begin  { string }
        fcs($b3);     { mov bl,00 }
        fcs($00);
        fcs($88); { mov [0000],bl }
        fcs($1e);
        fcs($00);
        fcs($00);
        Digit(t);
        if cc=0 then skan(cc,tt,nn);   { пpобел }
        while (cc=5) and (tt=13) do           { + }
         begin
          skan(cc,tt,nn);
          Digit(t);
          if cc=0 then skan(cc,tt,nn); { пpобел }
         end;
       end;
{------}
     else error(29);
    end;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Augend(t:byte);
   var
    oper:boolean;
   begin
    if cc=0 then skan(cc,tt,nn); { пpобел }
    case t of
{------}
     1:begin                                    { byte }
        Factor(t);
        if cc=0 then skan(cc,tt,nn);          { пpобел }
        while (cc=5) and ((tt=10) or (tt=16)) do     { * / }
         begin
          oper:=tt=10;            { * }
          fcs($50);         { push ax }
          skan(cc,tt,nn);
          Factor(t);
          if oper then
           begin
            fcs($5B);        { pop bx }
            fcs($F6);         { mul bl}
            fcs($E3);
            fcs($80);        {cmp ah,0}
            fcs($fc);
            fcs($00);
            fcs($74);         { je +3 }
            fcs($03);
            fcs($e9);     { jmp error }
            fcsw($39-cs0-2);
           end
                  else
           begin
            fcs($89);  {mov bx,ax}
            fcs($c3);
            fcs($58);   { pop ax }
            fcs($b4); { mov ah,0 }
            fcs($00);
            fcs($f6);   { div bl }
            fcs($f3);
           end;
          if cc=0 then skan(cc,tt,nn);  { пpобел }
         end;
       end;
{------}
     2:begin                           { integer }
        Factor(t);
        if cc=0 then skan(cc,tt,nn);    { пpобел }
        while (cc=5) and ((tt=10) or (tt=16)) do { * / }
         begin
          oper:=tt=10;            { * }
          fcs($50);         { push ax }
          skan(cc,tt,nn);
          Factor(t);
          if oper then
           begin
            fcs($5B);    { pop bx }
            fcs($F7);    { imul bx}
            fcs($Eb);
            fcs($81);    {cmp dx,0}
            fcs($fa);
            fcs($00);
            fcs($00);
            fcs($74);   { je +3+6 }
            fcs($09);

            fcs($81); {cmp dx,ffff}
            fcs($fa);
            fcs($ff);
            fcs($ff);

            fcs($74);     { je +3 }
            fcs($03);
            fcs($e9); { jmp error }
            fcsw($39-cs0-2);
           end
                  else
           begin
            fcs($89);     {mov bx,ax}
            fcs($c3);
            fcs($58);      { pop ax }
            fcs($99); {cwd ax> dx:ax}
            fcs($f7);      { idiv bx}
            fcs($fb);
           end;
          if cc=0 then skan(cc,tt,nn);  { пpобел }
         end;
       end;
{------}
     3:begin   { word }
        Factor(t);
        if cc=0 then skan(cc,tt,nn);          { пpобел }
        while (cc=5) and
              ((tt=10) or (tt=16)) do         { * / }
         begin
          oper:=tt=10;        { * }
          fcs($50);     { push ax }
          skan(cc,tt,nn);
          Factor(t);
          if oper then
           begin
            fcs($5B);    { pop bx }
            fcs($F7);     { mul bl}
            fcs($E3);
            fcs($81);    {cmp dx,0}
            fcs($fa);
            fcs($00);
            fcs($00);
            fcs($74);     { je +3 }
            fcs($03);
            fcs($e9); { jmp error }
            fcsw($39-cs0-2);
           end
                  else
           begin
            fcs($29); {sub dx,dx}
            fcs($eb);
            fcs($89); {mov bx,ax}
            fcs($c3);
            fcs($58);  { pop ax }
            fcs($f7);   { div bx}
            fcs($f3);
           end;
          if cc=0 then skan(cc,tt,nn);  { пpобел }
         end;
       end;
{------}
     4:begin                           { boolean }
        Factor(t);
        if cc=0 then skan(cc,tt,nn);    { пpобел }
        while (cc=1) and (nn=36) do          { and }
         begin
          fcs($50);                    { push ax }
          skan(cc,tt,nn);
          Factor(t);
          fcs($5B);  { pop bx }
          fcs($20);  { and al,bl }
          fcs($d8);
          if cc=0 then skan(cc,tt,nn); { пpобел }
         end;
       end;
{------}
     else error(29);
    end;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Factor(t:byte);
   var
    oper:boolean;
   begin
    if cc=0 then skan(cc,tt,nn);   { пpобел }
    case t of
{------}
     1,3:begin     {byte,word}
          if (cc=5) and (tt=6) then       { ( }
           begin
            skan(cc,tt,nn);
            Sign(t);
            if cc=0 then skan(cc,tt,nn);        { пpобел }
            if (cc<>5) or (tt<>7) then error(37); { ) }
            skan(cc,tt,nn);
           end
                             else Digit(t);
         end;
{------}
     2:begin       { integer }
        if (cc=5) and ((tt=14) or (tt=13)) then { - + }
         begin
          oper:=((cc=5) and (tt=14)); { - }
          skan(cc,tt,nn);
          Factor(t);
          if cc=0 then skan(cc,tt,nn); { пpобел }
          if oper then
           begin
            fcs($f7);  { neg ax }
            fcs($d8);
           end;
         end
                                       else
         begin
          if (cc=5) and (tt=6) then  { ( }
           begin
            skan(cc,tt,nn);
            Sign(t);
            if cc=0 then skan(cc,tt,nn); { пpобел }
            if (cc<>5) or (tt<>7) then error(37); { ) }
            skan(cc,tt,nn);
           end
                             else
           begin
            Digit(t);
           end;
         end;
       end;
{------}
     4:begin  { boolean }
        if (cc=1) and (nn=38) then { not }
         begin
          skan(cc,tt,nn);
          Factor(t);
          if cc=0 then skan(cc,tt,nn); { пpобел }
          fcs($f6);  { not al }
          fcs($d0);
          fcs($24);  { and al,01 }
          fcs($01);
         end
                            else
         begin
          if (cc=5) and (tt=11) then  { [ }
           begin
            skan(cc,tt,nn);
            Sign(t);
            if cc=0 then skan(cc,tt,nn); { пpобел }
            if (cc<>5) or (tt<>12) then error(19);  { ] }
            skan(cc,tt,nn);
           end
                             else
           begin
            Digit(t);
           end;
         end;
       end;
{------}
     else error(29);
    end;
   end;
{╠════════════════════════════════════════════════════════╣}
  procedure Digit(t:byte);
   var
    a1,at:byte;
    a2:integer;
    a3:word;
    oper:byte;
   begin
    if cc=0 then skan(cc,tt,nn); { пpобел }
    case t of
{------}
     1:begin       {***byte***}
        case cc of
         7:begin   { const }
            if DigCst>$ff then error(9);
            a1:=DigCst;
            fcs($b0);         {mov al,a1}
            fcs(a1);
            skan(cc,tt,nn);
           end;
         3:begin              { пеpемен.}
            Nam2Tp(at);
            case at of
             1:begin             { byte }
                fcs($8a);   {mov al,[di]}
                fcs($05);
               end;
             2,3:begin      { integer/word }
                  fcs($8b); {mov ax,[di]}
                  fcs($05);
                  fcs($80);    {cmp ah,0}
                  fcs($fc);
                  fcs($00);
                  fcs($74);     { je +3 }
                  fcs($03);
                  fcs($e9); { jmp error }
                  fcsw($39-cs0-2);
                 end
             else error(30);
            end;
           end;
         else error(30);
        end;
       end;
{------}
     2:begin       {*integer*}
        case cc of
         7:begin        { число }
            if (DigCst>$8fff) then error(9);
            a2:=DigCst;
            if a2<0 then a2:=-a2;
            fcs($b8);    {mov ax,a2}
            fcsw(a2);
            skan(cc,tt,nn);
           end;
         3:begin          { пеpемен.}
            Nam2Tp(at);
            case at of
             1:begin              { byte }
                fcs($8a);    {mov al,[di]}
                fcs($05);
                fcs($b4);       {mov ah,0}
                fcs($00);
               end;
             2:begin           { integer }
                fcs($8b);    {mov ax,[di]}
                fcs($05);
               end;
             3:begin              { word }
                fcs($8b);    {mov ax,[di]}
                fcs($05);
                fcs($3d);      { cmp ax,0}
                fcs($00);
                fcs($00);
                fcs($7d);       { jge +3 }
                fcs($03);
                fcs($e9);    { jmp error }
                fcsw($39-cs0-2);
               end;
             else error(30);
            end;
           end;
         else error(30);
        end;
       end;
{------}
     3:begin       {*word*}
        case cc of
         7:begin     { число }
            if DigCst>$ffff then error(9);
            a3:=DigCst;
            fcs($b8);    {mov ax,a3}
            fcsw(a3);
            skan(cc,tt,nn);
           end;
         3:begin     { пеpемен.}
            Nam2Tp(at);
            case at of
             1:begin    { byte }
                fcs($8a); {mov al,[di]}
                fcs($05);
                fcs($b4);    {mov ah,0}
                fcs($00);
               end;
             2:begin        { integer }
                fcs($8b); {mov ax,[di]}
                fcs($05);
                fcs($3d);   { cmp ax,0}
                fcs($00);
                fcs($00);
                fcs($7d);    { jge +3 }
                fcs($03);
                fcs($e9); { jmp error }
                fcsw($39-cs0-2);
               end;
             3:begin            { word }
                fcs($8b);  {mov ax,[di]}
                fcs($05);
               end;
             else error(30);
            end;
           end;
         else error(30);
        end;
       end;
{------}
     4:begin       {**boolean**}
        case cc of
         1:begin    { const }
            if (nn<>1) and (nn<>2) then error(40);
            fcs($b0); {mov al,const}
            if nn=1 then fcs(0);
            if nn=2 then fcs(1);
            skan(cc,tt,nn);
           end;
         3:begin                { пеpемен.}
            Nam2Tp(at);
            case at of
             4:begin            {byte/word}
                fcs($8a);     {mov al,[di]}
                fcs($05);
               end;
             else error(41);
            end;
           end;
         else
          begin { выpажение < = > }
           {_( int < = > int )_}
           if (cc<>5) or (tt<>6) then error(34); { ( }
           skan(cc,tt,nn);
           if cc=0 then skan(cc,tt,nn); { пpобел }
           Sign(2);
           fcs($50);                    { push ax }
           if cc<>5 then error(40);
           case tt of
            8:begin                          { > }
               skan(cc,tt,nn);
               if (cc=5) and (tt=5) then
                begin                       { >= }
                 skan(cc,tt,nn);
                 oper:=4;
                end
                                  else oper:=1; { > }
              end;
            9:begin                             { < }
               skan(cc,tt,nn);
               if (cc=5) and (tt=5) then
                begin                           { <= }
                 skan(cc,tt,nn);
                 oper:=5;
                end
                                  else
                begin
                 if (cc=5) and (tt=8) then
                  begin                       { <> }
                   skan(cc,tt,nn);
                   oper:=3;
                  end
                                  else oper:=2;
                end;
              end;
            5:begin                         { = }
               skan(cc,tt,nn);
               oper:=0;
              end;
            else error(40);
           end;
           Sign(2);
           fcs($5B);     { pop bx }
           fcs($39);     { cmp bx,ax }
           fcs($c3);
           case oper of
            0:begin             { = }
               fcs($74);    { je +4 }
               fcs($04);
               fcs($b0); { mov al,0 }
               fcs($00);
               fcs($eb);   { jmp +2 }
               fcs($02);
               fcs($b0); { mov al,1 }
               fcs($01);
              end;
            1:begin             { > }
               fcs($7f);    { jg +4 }
               fcs($04);
               fcs($b0); { mov al,0 }
               fcs($00);
               fcs($eb);   { jmp +2 }
               fcs($02);
               fcs($b0); { mov al,1 }
               fcs($01);
              end;
            2:begin             { < }
               fcs($7c);    { jl +4 }
               fcs($04);
               fcs($b0); { mov al,0 }
               fcs($00);
               fcs($eb);   { jmp +2 }
               fcs($02);
               fcs($b0); { mov al,1 }
               fcs($01);
              end;
            3:begin           { < > }
               fcs($75);   { jne +4 }
               fcs($04);
               fcs($b0); { mov al,0 }
               fcs($00);
               fcs($eb);   { jmp +2 }
               fcs($02);
               fcs($b0); { mov al,1 }
               fcs($01);
              end;
            4:begin           { > = }
               fcs($7d);   { jge +4 }
               fcs($04);
               fcs($b0); { mov al,0 }
               fcs($00);
               fcs($eb);   { jmp +2 }
               fcs($02);
               fcs($b0); { mov al,1 }
               fcs($01);
              end;
            5:begin           { < = }
               fcs($7e);   { jle +4 }
               fcs($04);
               fcs($b0); { mov al,0 }
               fcs($00);
               fcs($eb);   { jmp +2 }
               fcs($02);
               fcs($b0); { mov al,1 }
               fcs($01);
              end;
           end;
           if cc=0 then skan(cc,tt,nn);  { пpобел }
           if (cc<>5) or (tt<>7) then error(37); { ) }
           skan(cc,tt,nn);
          end;
        end;
       end;
{------}
     7:begin       {*string*}
        case cc of
         8:begin       {const-string}
            fcs($EB);              { jmp ... }
            fcs(ord(LnCst[0]));
            a3:=cs0;
            for a1:=1 to ord(LnCst[0]) do
             fcs(ord(LnCst[a1]));
            fcs($1E);         { push ds }
            fcs($07);          { pop es }
            fcs($1E);         { push ds }
            fcs($8C);         {mov ax,cs}
            fcs($C8);
            fcs($8E);         {mov ds,ax}
            fcs($D8);
            fcs($BE);     {mov si,@const}
            fcsw(a3);
            fcs($26); { mov al,es:[0000]}
            fcs($a0);
            fcsw(0);
            fcs($b4);       { mov ah,00 }
            fcs($00);
            fcs($89);         {mov di,ax}
            fcs($c7);
            fcs($47);           { inc di}
            fcs($05);     { add ax,const}
            fcsw(ord(LnCst[0]));
            fcs($3d);  { cmp ax,255 }
            fcs($ff);
            fcs($00);
            fcs($7f);      { jg +05 }
            fcs($05);
            fcs($B9);     {mov cx,..}
            fcsw(ord(LnCst[0]));
            fcs($eb);          { jmp +08 }
            fcs(08);
            fcs($b9);       { mov cx,255 }
            fcs($ff);
            fcs($00);
            fcs($26); { sub cl,es:[0000] }
            fcs($2a);
            fcs($0e);
            fcsw(0);
            fcs($26); { add es:[0000],cl }
            fcs($00);
            fcs($0e);
            fcsw(0);
            fcs($FC);              { cld }
            fcs($F3);          {rep movsb}
            fcs($A4);
            fcs($1F);           { pop ds }
            skan(cc,tt,nn);
           end;
         3:begin   { var }
            Nam2Tp(at);
            case at of
             6:begin   { char }
                fcs($a0); { mov al,[0000]}
                fcsw(0);
                fcs($b4);    { mov ah,00 }
                fcs($00);
                fcs($40);       { inc ax }
                fcs($3d);   { cmp ax,255 }
                fcs($ff);
                fcs($00);
                fcs($7f);       { jg +9 }
                fcs(9);
                fcs($a2); { mov[0000],al }
                fcsw(0);
                fcs($89);    { mov bx,ax }
                fcs($c3);
                fcs($8a);  { mov cl,[di] }
                fcs($0d);
                fcs($88);   { mov[bx],cl }
                fcs($0f);
               end;
             7:begin            { string }
                fcs($1E);      { push ds }
                fcs($07);       { pop es }
                fcs($89);      {mov si,di}
                fcs($fe);
                fcs($46);       { inc si }
                fcs($26);  { mov al,es:[0000]}
                fcs($a0);
                fcsw(0);
                fcs($b4);        { mov ah,00 }
                fcs($00);
                fcs($50);          { push ax }
                fcs($b5);          {mov ch,00}
                fcs($00);
                fcs($8a);        {mov cl,[di]}
                fcs($0d);
                fcs($01);        { add ax,cx }
                fcs($c8);
                fcs($3d);       { cmp ax,255 }
                fcs($ff);
                fcs($00);
                fcs($7f);           { jg +06 }
                fcs($06);
                fcs($85);        { mov ch,00 }
                fcs($00);
                fcs($8a);        {mov cl,[di]}
                fcs($0d);
                fcs($eb);          { jmp +08 }
                fcs(08);
                fcs($b9);       { mov cx,255 }
                fcs($ff);
                fcs($00);
                fcs($26); { sub cl,es:[0000] }
                fcs($2a);
                fcs($0e);
                fcsw(0);
                fcs($26); { add es:[0000],cl }
                fcs($00);
                fcs($0e);
                fcsw(0);
                fcs($5f);           { pop di }
                fcs($47);            { inc di}
                fcs($FC);              { cld }
                fcs($F3);          {rep movsb}
                fcs($A4);
               end;
             else error(30);
            end;
           end;
         else error(30);
        end;
       end;
{------}
     else error(29);
    end;
   end;
{╚════════════════════════════════════════════════════════╝}
  begin
   BEGIN0;
   skan(cc,tt,nn);
   Header;
   Block;
   if cc=0 then skan(cc,tt,nn);         { пpобел }
   if (cc<>5) and (tt<>1) then error(10); { . }
   END0;
  end;
{------------------------------------------------}
 Procedure progr;
  var
   i:word;
   b:byte;
  begin
   MyDsEs:=@Banner;
   for i:=0 to 511 do write(fout,MyDsEs^[i]);
   for i:=0 to cs0-1 do write(fout,cs^[i]);
   b:=0;
   for i:=1 to ds0 do write(fout,b);
   b:=0;
   for i:=1 to ss0 do write(fout,b);
  end;
{------------------------------------------------}
 Begin
  Inic;
  Exe;
  Progr;
  Clos;
  writeln(' ',number-1,' lines;  CS:',cs0,';  DS:',ds0,';  SS:',ss0);
 End.
